package com.project2.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.project2.bean.CommonData;
import com.project2.bean.PageBo;
import com.project2.bean.po.*;
import com.project2.bean.vo.WxCouponListVo;
import com.project2.bean.vo.WxCouponMyListVo;
import com.project2.mapper.MarketCartMapper;
import com.project2.mapper.MarketCouponMapper;
import com.project2.mapper.MarketCouponUserMapper;
import com.project2.util.InformationUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
@Transactional
public class WxCouponServiceImpl implements WxCouponService {

    @Autowired
    MarketCouponMapper couponMapper;

    @Autowired
    MarketCouponUserMapper couponUserMapper;

    @Autowired
    MarketCartMapper cartMapper;

    @Autowired
    MarketCartMapper marketCartMapper;

    /**
     * 显示用户还可以领取的优惠卷
     * 那么哪些优惠卷可以领？
     * 1.大前提，未被删除的，删除的甚至不应该被显示
     * 2.status状态为0，即正常可用
     * 3.限量了但是用户领取数量没有达到上限的（需要判断用户手上的限量卷是否已经被用掉）
     * 4.领取卷，不能是注册卷和兑换码卷
     *
     * TODO 怎么维护优惠卷的过期和下架？
     * @author Frank Zhu
     */
    @Override
    public CommonData getCouponList(PageBo pageBo, Integer userId) {
        // 获取用户所有的重复的优惠卷id
        List<Integer> uCouponIds = couponUserMapper.getUsersCouponIdRepeated(userId);
        List<Integer> blackList = new ArrayList<>();
        if (uCouponIds.size()!=0){
            // 获取用户所有不重复的优惠卷id
            List<Integer> uCouponIdsUnrepeated = uCouponIds.stream().distinct().collect(Collectors.toList());

            // 获取到对应的优惠卷信息
            MarketCouponExample mappedCouponsExample = new MarketCouponExample();
            MarketCouponExample.Criteria mappedCouponsCriteria = mappedCouponsExample.createCriteria();
            mappedCouponsCriteria.andIdIn(uCouponIdsUnrepeated);
            List<MarketCoupon> mappedCoupons = couponMapper.selectByExample(mappedCouponsExample);
            // 设一个黑名单List
            for (MarketCoupon mappedCoupon : mappedCoupons) {
                // 遍历信息，并获取到id
                Integer couponId = mappedCoupon.getId();
                // 获得该优惠卷的限量数
                Short limit = mappedCoupon.getLimit();
                // 仅考察限量的优惠卷
                if(limit >= 1){
                    // 使用stream获取该限量的优惠卷在用户手上有几张
                    long count = uCouponIds.stream().filter(d -> d == couponId.intValue()).count();
                    // 如果当前持有数量已经大于等于限定数量，将这种优惠卷加入临时黑名单
                    if(count >= limit){
                        blackList.add(couponId);
                    }
                }
            }
        }
        PageHelper.startPage(pageBo.getPage(),pageBo.getLimit());
        MarketCouponExample example = new MarketCouponExample();
        MarketCouponExample.Criteria criteria = example.createCriteria();
        // 未被删除的
        criteria.andDeletedEqualTo(false);
        //找未过期的劵
        criteria.andStatusEqualTo((short)0);
        // 卷数量大于0的
        criteria.andTotalGreaterThanOrEqualTo(0);
        // 未在该用户临时优惠卷黑名单之中的
        if (blackList.size()>0){
            criteria.andIdNotIn(blackList);
        }
        // 状态为正常可用的
        criteria.andStatusEqualTo((short)0);

        List<MarketCoupon> marketCoupons = couponMapper.selectByExample(example);

        PageInfo<MarketCoupon> pageInfo = new PageInfo<>(marketCoupons);

        // TODO 先试试能否用po返回所有的信息（会有多余的）
        // List<MarketCoupon> pagedList = pageInfo.getList();
        // ArrayList<WxCouponListVo> finalCouponList = new ArrayList<>();
        // for (MarketCoupon marketCoupon : pagedList) {
        //     WxCouponListVo vo = new WxCouponListVo();
        // }

        return CommonData.data(pageInfo);
    }

    private void createUserCoupon(Integer couponId, Integer userId, MarketCoupon marketCoupon) {
        // 在coupon_user表中插入用户持有优惠卷的数据
        MarketCouponUser userData = new MarketCouponUser();
        userData.setUserId(userId);
        userData.setCouponId(couponId);
        userData.setStatus((short)0);
        userData.setDeleted(false);
        Date now = new Date();
        userData.setAddTime(now);
        userData.setUpdateTime(now);

        // 确定优惠卷的开始和结束时间
        if(marketCoupon.getTimeType() == 0){
            int days = marketCoupon.getDays().intValue();
            Calendar calendarNow = Calendar.getInstance();
            calendarNow.add(Calendar.DAY_OF_YEAR, days);
            Date expiredTime = calendarNow.getTime();
            userData.setStartTime(now);
            userData.setEndTime(expiredTime);
        }else {
            userData.setStartTime(marketCoupon.getStartTime());
            userData.setEndTime(marketCoupon.getEndTime());
        }

        couponUserMapper.insertSelective(userData);
    }

    @Override
    public CommonData mylist(Integer userId, Short status, PageBo pageBo) {
        MarketCouponUserExample example = new MarketCouponUserExample();
        MarketCouponUserExample.Criteria criteria = example.createCriteria();
        criteria.andUserIdEqualTo(userId);
        criteria.andStatusEqualTo(status);
        criteria.andDeletedEqualTo(false);
        // 分页开始
        PageHelper.startPage(pageBo.getPage(), pageBo.getLimit());
        List<MarketCouponUser> usersCouponList = couponUserMapper.selectByExample(example);

        // 获得分页结果
        PageInfo<MarketCouponUser> pageInfo = new PageInfo<>(usersCouponList);

        // 如果根本找不到任何优惠卷，返回空list
        if(pageInfo.getList().size() == 0){
            return CommonData.data(pageInfo);
        }

        // 用户优惠卷记录中如果有符合条件的信息才进行进一步的处理
        // availble使用来指定优惠卷能不能用的，这个只有在selectiveList里才有实际的作用
        CommonData<WxCouponMyListVo> data = getWxCouponMyListVoCommonData(pageInfo, false);

        return data;
    }

    /**
     * 处理分页后的用户优惠卷信息成vo对象返回
     * @param pageInfo
     * @param available
     * @return
     */
    private CommonData<WxCouponMyListVo> getWxCouponMyListVoCommonData(PageInfo<MarketCouponUser> pageInfo, Boolean available) {
        // 当前页需要显示的对应持有优惠卷
        List<MarketCouponUser> originalUsersCouponInfos = pageInfo.getList();

        // 不重复的优惠卷id
        List<Integer> couponsIds = originalUsersCouponInfos.stream()
                .map(a -> a.getCouponId()).distinct().collect(Collectors.toList());

        MarketCouponExample couponExample = new MarketCouponExample();
        MarketCouponExample.Criteria couponExampleCriteria = couponExample.createCriteria();
        couponExampleCriteria.andIdIn(couponsIds);
        // 这里去获取当前list中对应的优惠卷详情不应该再加上其他的附加条件了
        // 因为保证数据的正确行应该有外层来做，这个方法只做数据的凭借

        // 用户持有的优惠卷的详情
        List<MarketCoupon> couponsInfo = couponMapper.selectByExample(couponExample);

        // 用于最终返回的信息list
        ArrayList<WxCouponMyListVo> vos = new ArrayList<>();

        // 遍历用户的优惠卷list，将数据整合成vo并封装进commondata
        for (MarketCouponUser originalInfo : originalUsersCouponInfos) {
            // 从关系信息中获得id和优惠卷cid
            Integer id = originalInfo.getId();
            Integer cid = originalInfo.getCouponId();
            // 生效和失效时间应该从用户优惠卷表中取，两种timeType是统一的
            Date startTime = originalInfo.getStartTime();
            Date endTime = originalInfo.getEndTime();

            // 通过cid从优惠卷中过滤出对应的优惠卷
            // 但是对于被删除的优惠卷，因为之前从数据库中抽取时被排除了，最终list会为空
            List<MarketCoupon> tempList = couponsInfo.stream()
                    .filter(a -> a.getId().intValue() == cid.intValue()).collect(Collectors.toList());

            // 只要用户有可用的卷，tempList就不可能为空

            // 取出对应的优惠卷对象，抽取并填充描述信息
            MarketCoupon currentCouponInfo = tempList.get(0);
            Double discount = currentCouponInfo.getDiscount();
            Double min = currentCouponInfo.getMin();
            String desc = currentCouponInfo.getDesc();
            String name = currentCouponInfo.getName();
            String tag = currentCouponInfo.getTag();

            // 通过有参构造封装
            WxCouponMyListVo vo =
                    new WxCouponMyListVo(id, cid, discount, min, desc, name, tag, startTime, endTime, available);

            vos.add(vo);
        }

        CommonData<WxCouponMyListVo> data = new CommonData<>();
        data.setPage(pageInfo.getPageNum());
        data.setPages(pageInfo.getPages());
        data.setLimit(pageInfo.getPageSize());
        data.setTotal((int)pageInfo.getTotal());
        data.setList(vos);
        return data;
    }

    /**
     * 部分逻辑从杰哥处复制
     * @param cartId 购物车id
     * @param user 用户信息
     * @author Frank Zhu
     */
    @Override
    public CommonData selectCouponThatUserCanUse(Integer cartId, MarketUser user) {
        // 由于前端没有给到PageBo，自己造一个
        PageBo pageBo = new PageBo();
        pageBo.setPage(1);
        pageBo.setLimit(10);

        // 获取到用户当前勾选的所有商品，并且在最后得到总的金额
        Integer userId = user.getId();
        MarketCartExample marketCartExample = new MarketCartExample();
        MarketCartExample.Criteria criteria1 = marketCartExample.createCriteria();

        criteria1.andDeletedEqualTo(false);
        criteria1.andUserIdEqualTo(userId);
        criteria1.andCheckedEqualTo(true);
        if (cartId!=0) {
            criteria1.andIdEqualTo(cartId);
        }
        List<MarketCart> marketCarts = marketCartMapper.selectByExample(marketCartExample);
        Double checkedAmount=0.0;
        for (MarketCart marketCart : marketCarts) {
            checkedAmount+=marketCart.getNumber()*marketCart.getPrice().intValue();
        }
        // 当前勾选商品的总金额
        BigDecimal min = new BigDecimal(checkedAmount);

        // 开始检索符合条件的，所有商城中已有的，优惠卷
        MarketCouponExample couponInfoExample = new MarketCouponExample();
        MarketCouponExample.Criteria couponInfoCriteria = couponInfoExample.createCriteria();
        couponInfoCriteria.andDeletedEqualTo(false);
        // 状态0，该卷还正常可用（对商城而言）
        couponInfoCriteria.andStatusEqualTo((short)0);
        // 低消要求的卷
        couponInfoCriteria.andMinLessThanOrEqualTo(min);

        List<MarketCoupon> marketCoupons = couponMapper.selectByExample(couponInfoExample);

        // 如果商城中都没有卷，用户更不可能有卷可用
        if(marketCoupons.size() == 0){
            CommonData<WxCouponMyListVo> nullData = new CommonData<>();
            nullData.setPage(1);
            nullData.setPages(1);
            nullData.setLimit(10);
            nullData.setTotal(0);
            ArrayList<WxCouponMyListVo> emptyList = new ArrayList<>();
            nullData.setList(emptyList);
            return nullData;
        }

        // 得到这些优惠卷id的list
        List<Integer> finalIds = marketCoupons.stream().map(a -> a.getId()).collect(Collectors.toList());

        // 开启分页
        PageHelper.startPage(pageBo.getPage(),pageBo.getLimit());

        // 从用户手中检索到符合条件的优惠卷
        MarketCouponUserExample couponUnusedExample = new MarketCouponUserExample();
        MarketCouponUserExample.Criteria couponUnusedCriteria = couponUnusedExample.createCriteria();
        // 当前用户
        couponUnusedCriteria.andUserIdEqualTo(userId);
        // 用户未使用的卷
        couponUnusedCriteria.andStatusEqualTo((short)0);
        // 将之前获取到的能被使用的优惠卷id也增加进检索条件
        couponUnusedCriteria.andCouponIdIn(finalIds);
        couponUnusedCriteria.andDeletedEqualTo(false);

        List<MarketCouponUser> couponUnused = couponUserMapper.selectByExample(couponUnusedExample);

        PageInfo<MarketCouponUser> marketCouponUserPageInfo = new PageInfo<>(couponUnused);

        // 如果没有可用的卷
        if (marketCouponUserPageInfo.getList().size() == 0) {
            return CommonData.data(marketCouponUserPageInfo);
        }

        CommonData<WxCouponMyListVo> finalData = getWxCouponMyListVoCommonData(marketCouponUserPageInfo, true);

        return finalData;
    }


    @Override
    public Boolean exchange(Integer userId, String inputCode) {

        // 先从数据库中获取所有可用的兑换码卷
        MarketCouponExample couponExample = new MarketCouponExample();
        MarketCouponExample.Criteria couponCriteria = couponExample.createCriteria();
        couponCriteria.andDeletedEqualTo(false);
        couponCriteria.andTypeEqualTo((short)2);
        couponCriteria.andStatusEqualTo((short)0);

        List<MarketCoupon> coupons = couponMapper.selectByExample(couponExample);

        // 说明没有可用的兑换卷
        if (coupons.size() == 0) {
            return false;
        }


        MarketCoupon targetCoupon = null;

        // 检查是否有对应的卷
        for (MarketCoupon coupon : coupons) {
            String code = coupon.getCode();
            if(inputCode.equals(inputCode)){
                targetCoupon = coupon;
                break;
            }
        }

        // 为空说明兑换码是无效的
        if(targetCoupon == null){
            return false;
        }

        // 代码复用
        return receive(targetCoupon.getId(), userId);

        // MarketCoupon targetCoupon = coupons.get(0);
        //
        // if(targetCoupon.getLimit() > 0 && targetCoupon.getTotal() <= 0){
        //     return false;
        // }
        //
        // if(targetCoupon.getLimit() > 0 && targetCoupon.getTotal() == 1){
        //     // 限量卷，只剩一张，减去数量后，更新优惠卷的信息
        //     targetCoupon.setTotal(0);
        //     // 设置为下架
        //     targetCoupon.setStatus((short)2);
        //     // 更新updateTime
        //     targetCoupon.setUpdateTime(new Date());
        //     // 更新
        //     couponMapper.updateByPrimaryKey(targetCoupon);
        // }else {
        //     targetCoupon.setTotal(targetCoupon.getTotal() - 1);
        //     // 更新
        //     couponMapper.updateByPrimaryKey(targetCoupon);
        // }
        //
        // createUserCoupon(targetCoupon.getId(), userId, targetCoupon);
        //
        // return true;
    }

    /**
     * 用户获取优惠卷，三次数据库的操作
     *
     * 需要特别注意，数据库中对于limit字段的定义为
     * 0，不限量，所以拿的时候不需要管total
     * 1，即限领一张
     *
     * timeType，0为基于限定的天数，当用户将优惠卷娶到手之后，用户优惠卷记录中要记录开始和过期时间
     * 1，则是优惠卷有指定时间范围
     *
     * @param couponId 优惠卷id
     * @param userId 用户id
     * @return
     * @author Frank Zhu
     */
    @Override
    public Boolean userGetCoupon(Integer couponId, Integer userId) {
        // 先将优惠卷信息拿到
        MarketCoupon marketCoupon = couponMapper.selectByPrimaryKey(couponId);
        Integer total = marketCoupon.getTotal();
        // 如果是限量卷，且数量已经不能再领取，返回false
        if(marketCoupon.getLimit() > 0 && total < 0){
            return false;
        }

        // 虽然list部分会不显示用户不能够再领取的优惠卷
        // 但是如果在receive中不去增加用户领取数量达到限定而无法领取的条件
        // 会因为可领取list页面在用户领取之后不刷新页面导致用户无限领卷
        long count = couponUserMapper.getUsersCouponIdRepeated(userId).stream().filter(a -> a.intValue() == couponId.intValue()).count();
        if(count >= marketCoupon.getLimit()){
            return false;
        }

        if(marketCoupon.getLimit() > 0 && total == 1){
            // 限量卷，只剩一张，减去数量后，更新优惠卷的信息
            marketCoupon.setTotal(0);
            // 设置为下架
            marketCoupon.setStatus((short)2);
            // 更新updateTime
            marketCoupon.setUpdateTime(new Date());
            // 更新
            couponMapper.updateByPrimaryKey(marketCoupon);
        }else {
            marketCoupon.setTotal(total - 1);
            // 更新
            couponMapper.updateByPrimaryKey(marketCoupon);
        }
        createUserCoupon(couponId, userId, marketCoupon);

        return true;
    }

    /**
     * 8月15晚第二版
     * 显示用户还可以领取的优惠卷
     * 那么哪些优惠卷可以领？
     * 1.大前提，未被删除的，删除的甚至不应该被显示
     * 2.status状态为0，即正常可用
     * 3.限量了但是用户领取数量没有达到上限的（需要判断用户手上的限量卷是否已经被用掉）
     * 4.领取卷，不能是注册卷和兑换码卷
     *
     * userCopuons代表用户手上所有可用的卷，couponId可能重复
     *
     * @author Frank Zhu
     */
    @Override
    public CommonData list(PageBo pageBo, Integer userId){
        // 获得用户手上可用的卷的信息
        MarketCouponUserExample userCouponsExample = new MarketCouponUserExample();
        MarketCouponUserExample.Criteria userCouponsCriteria = userCouponsExample.createCriteria();
        userCouponsCriteria.andStatusEqualTo((short)0);
        userCouponsCriteria.andUserIdEqualTo(userId);
        userCouponsCriteria.andDeletedEqualTo(false);
        List<MarketCouponUser> userCoupons = couponUserMapper.selectByExample(userCouponsExample);

        List<Integer> couponIdsBlackList = new ArrayList<>();

        // 先创建商城中所有可以被领取的卷，后面再根据情况增加限定条件
        MarketCouponExample targetCouponsExample = new MarketCouponExample();
        MarketCouponExample.Criteria targetCouponsCriteria = targetCouponsExample.createCriteria();
        // 可用
        targetCouponsCriteria.andStatusEqualTo((short)0);
        // 类型为领取卷
        targetCouponsCriteria.andTypeEqualTo((short)0);
        // 未被删除
        targetCouponsCriteria.andDeletedEqualTo(false);
        // 数量还足以被领取
        targetCouponsCriteria.andTotalGreaterThanOrEqualTo(0);

        // size为0，即没有可用的卷，可能是卷都删除了，也可能是卷都过期了
        if(userCoupons.size() == 0){

            // 商城中所有可以被领取的卷应该都显示
            PageHelper.startPage(pageBo.getPage(), pageBo.getLimit());
            List<MarketCoupon> allGetableCoupons = couponMapper.selectByExample(targetCouponsExample);
            PageInfo<MarketCoupon> pageInfo = new PageInfo<>(allGetableCoupons);
            return CommonData.data(pageInfo);

        }else {
            // 用户有领取过优惠卷，获取所有领取的优惠卷id,并且去重
            List<Integer> unrepeatedIds = userCoupons.stream().map(a -> a.getCouponId()).distinct().collect(Collectors.toList());

            // 优惠卷黑名单候选抽取，根据去重后的id找
            MarketCouponExample blackCandidateExample = new MarketCouponExample();
            MarketCouponExample.Criteria blackListExampleCriteria = blackCandidateExample.createCriteria();
            blackListExampleCriteria.andIdIn(unrepeatedIds);
            List<MarketCoupon> blackCandidate = couponMapper.selectByExample(blackCandidateExample);

            // 对持有的优惠卷进行考察
            for (MarketCoupon candidate : blackCandidate) {
                // 候选优惠卷id
                Integer candidateId = candidate.getId();
                // 候选优惠卷的领取数量限制
                int limit = candidate.getLimit().intValue();

                // 计算当前优惠卷用户已经领取过多少张
                long count = userCoupons.stream()
                        .map(a -> a.getCouponId())
                        .filter(b -> b.intValue() == candidateId.intValue()).count();

                // 用户持有的超过或这等于限制数量
                if(count >= limit){
                    // 将当前的优惠卷id加入黑名单
                    couponIdsBlackList.add(candidateId);
                }
            }

            // 至此黑名单收集完成，开启分页
            PageHelper.startPage(pageBo.getPage(), pageBo.getLimit());
            // 排除该用户的优惠卷黑名单
            targetCouponsCriteria.andIdNotIn(couponIdsBlackList);
            List<MarketCoupon> targetCoupons = couponMapper.selectByExample(targetCouponsExample);
            // 存在极端条件，用户所有限量领取卷都领取过，且数量都满，会是空串
            PageInfo<MarketCoupon> pageInfo = new PageInfo<>(targetCoupons);

            List<MarketCoupon> wealthInfo = pageInfo.getList();

            // TODO 这里用了InformationUtil,但是必须保证两边的成员变量类型和名字一样
            ArrayList<WxCouponListVo> wxCouponListVos = new ArrayList<>();
            for (int i = 0; i < wealthInfo.size(); i++) {
                MarketCoupon couponInfo = wealthInfo.get(i);
                WxCouponListVo wxCouponListVo = new WxCouponListVo();

                wxCouponListVo = InformationUtil.infoTransfer(wxCouponListVo, couponInfo);

                if(couponInfo.getTimeType() == 0){
                    wxCouponListVo.setStartTime(null);
                    wxCouponListVo.setEndTime(null);
                }else {
                    wxCouponListVo.setDays((short)0);
                }

                wxCouponListVos.add(wxCouponListVo);
            }

            CommonData<WxCouponListVo> data = new CommonData<>();
            data.setList(wxCouponListVos);
            data.setPage(pageInfo.getPageNum());
            data.setPages(pageInfo.getPages());
            data.setLimit(pageInfo.getPageSize());
            data.setTotal((int)pageInfo.getTotal());

            return data;
        }
    }

    @Override
    public Boolean receive(Integer couponId, Integer userId){
        // 先考察该卷能否被领取
        MarketCoupon candidate = couponMapper.selectByPrimaryKey(couponId);
        Integer total = candidate.getTotal();
        if(total < 0){
            return false;
        }

        // 用户还能不能领
        MarketCouponUserExample userCouponExample = new MarketCouponUserExample();
        MarketCouponUserExample.Criteria userExampleCriteria = userCouponExample.createCriteria();
        userExampleCriteria.andUserIdEqualTo(userId);
        userExampleCriteria.andCouponIdEqualTo(couponId);

        List<MarketCouponUser> userCoupons = couponUserMapper.selectByExample(userCouponExample);

        Integer limit = candidate.getLimit().intValue();

        if(userCoupons.size() >= limit){
            // 说明不能领
            return false;
        }

        // 到现在，优惠卷库存充足，用户也没有被限制领取
        // 开始对优惠卷进行数量更新，并且用户-优惠卷表要插入数据

        if(total == 0){
            // 直接插入新数据，库存不用管，因为是一个无限制卷
            userCouponNewInfo(userId, candidate);
        }else{
            //优惠卷数量要进行更新，更新后还需要检查是否应该因为数据不足而下架
            couponSubtract(candidate);
            userCouponNewInfo(userId, candidate);
        }
        return true;
    }

    /**
     * 新版本的用户-优惠卷新增信息
     * 与receive关联
     * @Date 08/15 23:00
     */
    private void userCouponNewInfo(Integer userId, MarketCoupon candidate) {
        MarketCouponUser userNewCoupon = new MarketCouponUser();
        Integer couponId = candidate.getId();
        userNewCoupon.setCouponId(couponId);
        userNewCoupon.setUserId(userId);
        userNewCoupon.setStatus((short)0);
        userNewCoupon.setDeleted(false);
        Date now = new Date();
        userNewCoupon.setAddTime(now);
        userNewCoupon.setUpdateTime(now);

        // 处理生效和失效时间
        // 1,领取后按天数指定。0，按本身的startTime和endTime填充。
        int timeType = candidate.getTimeType().intValue();
        if(timeType == 0){
            int days = candidate.getDays().intValue();
            Calendar calendarNow = Calendar.getInstance();
            calendarNow.add(Calendar.DAY_OF_YEAR, days);
            Date expiredTime = calendarNow.getTime();
            userNewCoupon.setStartTime(now);
            userNewCoupon.setEndTime(expiredTime);
        }else {
            userNewCoupon.setStartTime(candidate.getStartTime());
            userNewCoupon.setEndTime(candidate.getEndTime());
        }

        couponUserMapper.insertSelective(userNewCoupon);
    }

    /**
     * 减少对应优惠卷的数量
     * 被receive调用
     * @param candidate
     */
    private void couponSubtract(MarketCoupon candidate) {
        Integer total = candidate.getTotal();
        if((total-1) == 0){
            // 限量卷的total不能减少到0，否则就会判断为无限制的卷
            candidate.setTotal(-1);
            candidate.setStatus((short)2);
            candidate.setUpdateTime(new Date());
        }else {
            // 非临界值，直接减少数量即可
            candidate.setTotal(total - 1);
        }

        couponMapper.updateByPrimaryKey(candidate);
    }

    // @Override
    // public CommonData mylist(Integer userId, Short status, PageBo pageBo) {
    //     // 先看看用户有没有这种状态的优惠卷，没有就返回空表
    //     MarketCouponUserExample userCouponListExample = new MarketCouponUserExample();
    //     MarketCouponUserExample.Criteria userCouponListExampleCriteria = userCouponListExample.createCriteria();
    //     userCouponListExampleCriteria.andUserIdEqualTo(userId);
    //     userCouponListExampleCriteria.andDeletedEqualTo(false);
    //     userCouponListExampleCriteria.andStatusEqualTo(status);
    //
    //     PageHelper.startPage(pageBo.getPage(), pageBo.getLimit());
    //
    //     List<MarketCouponUser> userCouponList = couponUserMapper.selectByExample(userCouponListExample);
    //
    //     PageInfo<MarketCouponUser> pageInfo = new PageInfo<>(userCouponList);
    //     if(pageInfo.getList().size() == 0){
    //         return CommonData.data(pageInfo);
    //     }
    //
    //     return null;
    // }


}
